#pragma once
#include<iostream>
#include<string>
#include <jsoncpp/json/json.h>
using namespace std;

#define Myself 1
const string blank_space_sep=" ";
const string protocal_sep="\n";

string Encode(string &content)
{//添加报头信息
    string package=to_string(content.size());//有效载荷长度
    package+=protocal_sep;
    package+=content;
    package+=protocal_sep;
    return package;
}
bool Decode(string &package,string *content)
{
    size_t pos=package.find(protocal_sep);
    if(pos==string::npos) return false;
    string len_str=package.substr(0,pos);
    size_t len=stoi(len_str);
    size_t total_len=len_str.size()+len+2;//判断整个长度是否符合协议
    if(package.size()<total_len) return false;
    *content=package.substr(pos+1,len);
    //删除已解析的报文
    package.erase(0,total_len);
    return true;
}
class Request
{
public:
    Request(int data1,int data2,char oper) :x(data1),y(data2),op(oper)
    {}
    Request()//适配反序列化场景，先创建一个空对象，接收读取的字节流
    {}
    ~Request()
    {}
public:
    bool Serialize(string *out)
    {
#ifdef MySelf//使用条件编译
        //构建报文的有效载荷 "x op y
        string s=to_string(x);
        s+=blank_space_sep;
        s+=op;
        s+=blank_space_sep;
        s+=to_string(y);
        *out=s;
        return true;
#else
        Json::Value root;// 初始化一个空的 JSON 节点（默认是 null）
        root["x"]=x;
        root["y"]=y;
        root["op"]=op;
        //Json::FastWriter w;//将对象转换为 JSON 字符串的工具类（即 “序列化” 操作）
        Json::StyledWriter w;// 创建格式化写入器
        *out=w.write(root);// 将 root 转换为字符串，存入 out 指向的内存
        return true;
#endif
    }

    bool Deserialize(const string &in)
    {
#ifdef MySelf
        size_t left=in.find(blank_space_sep);
        if(left==string::npos) return false;
        string part_x=in.substr(0,left);
        size_t right=in.rfind(blank_space_sep);//反向查找
        if(right==string::npos) return false;
        string part_y =in.substr(right+1);

        if(left+2!=right) return false;//判断字符串格式是否正确
        op=in[left+1];
        x=stoi(part_x);
        y=stoi(part_y);
        return true;
#else
        Json::Value root;// 空容器，准备存储解析后的 JSON 数据
        Json::Reader r;// 解析器实例，负责字符串到 JSON 结构的转换
        r.parse(in,root);
        x=root["x"].asInt();
        y=root["y"].asInt();
        op=root["op"].asInt();
        return true;
#endif
    }
    void DebugPrint()
    {
        cout<<"新请求构建完成："<<x<<op<<y<<"=?"<<endl;
    }
public:
//序列化为 x op y的形式
    int x;
    int y;
    char op;//+ - * / %
};

class Response
{
public:
    Response(int res,int c) :result(res),code(c)
    {}
    Response() {}
    ~Response()
    {}
public:
    bool Serialize(string *out)
    {
#ifdef MySelf
        string s=to_string(result);
        s+=blank_space_sep;
        s+=to_string(code);
        *out=s;
        return true;
#else
        Json::Value root;
        root["result"]=result;
        root["code"]=code;
        //Json::FastWriter w;
        Json::StyledWriter w;
        *out=w.write(root);
        return true;
#endif
    }
    bool Deserialize(string &in)
    {
#ifdef MySelf
        size_t pos=in.find(blank_space_sep);
        if(pos==string::npos) return false;
        string part_left=in.substr(0,pos);
        string part_right=in.substr(pos+1);
        result=stoi(part_left);
        code=stoi(part_right);
        return true;
#else
        Json::Value root;
        Json::Reader r;
        r.parse(in,root);
        result=root["result"].asInt();
        code=root["code"].asInt();
        return true;
#endif
    }
    void DebugPrint()
    {
        cout<<"结果响应完成，result："<<result<<", code: "<<code<<endl;
    }
public:
    int result;
    int code;
};